/*
 * Rust 整数字面量详解 - 二进制、八进制、十六进制
 * 
 * 本程序详细介绍了Rust中不同进制的整数字面量表示方法：
 * - 十进制 (Decimal):     默认进制，如 123, 1000
 * - 二进制 (Binary):      0b前缀，如 0b1010, 0b1111_0000
 * - 八进制 (Octal):       0o前缀，如 0o777, 0o123
 * - 十六进制 (Hexadecimal): 0x前缀，如 0xFF, 0xABCD
 * 
 * 学习目标：
 * 1. 掌握四种进制的整数字面量语法
 * 2. 理解不同进制之间的转换关系
 * 3. 学习实际编程中的应用场景
 * 4. 掌握格式化输出的方法
 * 5. 了解下划线分隔符的使用技巧
 * 6. 学习类型后缀在不同进制中的应用
 */

fn main() {
    println!("🦀 欢迎学习 Rust 整数字面量的不同进制表示！");
    println!("{}", "=".repeat(60));
    
    // ===== 第一部分：基础概念介绍 =====
    println!("\n📌 第一部分：进制系统基础概念");
    
    println!("计算机中常用的四种进制：");
    println!("📊 十进制 (Decimal):     基数10，数字0-9");
    println!("🔢 二进制 (Binary):      基数2，数字0-1，计算机内部存储");
    println!("🎯 八进制 (Octal):       基数8，数字0-7，Unix权限系统");
    println!("💎 十六进制 (Hexadecimal): 基数16，数字0-9，A-F，内存地址、颜色值");
    
    // ===== 第二部分：十进制字面量（默认） =====
    println!("\n📌 第二部分：十进制字面量（默认进制）");
    
    let decimal1 = 123;           // 普通十进制
    let decimal2 = 1_000_000;     // 使用下划线增强可读性
    let decimal3 = 42i32;         // 带类型后缀的十进制
    
    println!("十进制字面量示例：");
    println!("  123 = {}", decimal1);
    println!("  1_000_000 = {} (使用下划线分隔)", decimal2);
    println!("  42i32 = {} (带类型后缀)", decimal3);
    
    // ===== 第三部分：二进制字面量 =====
    println!("\n📌 第三部分：二进制字面量（0b前缀）");
    
    let binary1 = 0b1010;         // 二进制1010 = 十进制10
    let binary2 = 0b1111_0000;    // 二进制11110000 = 十进制240
    let binary3 = 0b1010_1010u8;  // 带类型后缀的二进制
    let binary4 = 0b1100_0011_1010_0101; // 长二进制数
    
    println!("二进制字面量示例：");
    println!("  0b1010 = {} (二进制)", binary1);
    println!("  0b1111_0000 = {} (二进制，使用下划线)", binary2);
    println!("  0b1010_1010u8 = {} (二进制，u8类型)", binary3);
    println!("  0b1100_0011_1010_0101 = {} (长二进制)", binary4);
    
    // 展示二进制的实际应用：位操作
    println!("\n二进制的典型应用场景：");
    let permissions = 0b111_101_101; // rwxr-xr-x 权限
    let mask = 0b1111_0000;         // 高4位掩码
    let flags = 0b0001_0100;        // 标志位
    
    println!("  Unix权限 rwxr-xr-x: 0b{:09b} = {}", permissions, permissions);
    println!("  位掩码 (高4位): 0b{:08b} = {}", mask, mask);
    println!("  标志位设置: 0b{:08b} = {}", flags, flags);
    
    // ===== 第四部分：八进制字面量 =====
    println!("\n📌 第四部分：八进制字面量（0o前缀）");
    
    let octal1 = 0o123;           // 八进制123 = 十进制83
    let octal2 = 0o777;           // 八进制777 = 十进制511
    let octal3 = 0o644u16;        // 带类型后缀的八进制
    let octal4 = 0o1_234_567;     // 使用下划线的八进制
    
    println!("八进制字面量示例：");
    println!("  0o123 = {} (八进制)", octal1);
    println!("  0o777 = {} (八进制)", octal2);
    println!("  0o644u16 = {} (八进制，u16类型)", octal3);
    println!("  0o1_234_567 = {} (八进制，使用下划线)", octal4);
    
    // 展示八进制的实际应用：Unix权限
    println!("\n八进制的典型应用场景（Unix文件权限）：");
    let perm_644 = 0o644; // rw-r--r--
    let perm_755 = 0o755; // rwxr-xr-x
    let perm_777 = 0o777; // rwxrwxrwx
    
    println!("  0o644 (rw-r--r--) = {}", perm_644);
    println!("  0o755 (rwxr-xr-x) = {}", perm_755);
    println!("  0o777 (rwxrwxrwx) = {}", perm_777);
    
    // ===== 第五部分：十六进制字面量 =====
    println!("\n📌 第五部分：十六进制字面量（0x前缀）");
    
    let hex1 = 0xFF;              // 十六进制FF = 十进制255
    let hex2 = 0xABCD;            // 十六进制ABCD = 十进制43981
    let hex3 = 0x1A2Bu32;         // 带类型后缀的十六进制
    let hex4 = 0xDEAD_BEEFu32;    // 使用下划线的十六进制
    
    println!("十六进制字面量示例：");
    println!("  0xFF = {} (十六进制)", hex1);
    println!("  0xABCD = {} (十六进制)", hex2);
    println!("  0x1A2Bu32 = {} (十六进制，u32类型)", hex3);
    println!("  0xDEAD_BEEF = {} (十六进制，使用下划线)", hex4);
    
    // 展示十六进制的实际应用
    println!("\n十六进制的典型应用场景：");
    let color_red = 0xFF0000;     // RGB红色
    let color_green = 0x00FF00;   // RGB绿色
    let color_blue = 0x0000FF;    // RGB蓝色
    let memory_addr = 0x7FFF_0000; // 内存地址
    
    println!("  RGB红色: 0x{:06X} = {}", color_red, color_red);
    println!("  RGB绿色: 0x{:06X} = {}", color_green, color_green);
    println!("  RGB蓝色: 0x{:06X} = {}", color_blue, color_blue);
    println!("  内存地址: 0x{:08X} = {}", memory_addr, memory_addr);
    
    // ===== 第六部分：进制转换对比 =====
    println!("\n📌 第六部分：同一数值的不同进制表示");
    
    let value = 255; // 选择255作为示例，因为它是u8的最大值
    
    println!("数值255在不同进制中的表示：");
    println!("  十进制: {}", value);
    println!("  二进制: 0b{:08b}", value);
    println!("  八进制: 0o{:o}", value);
    println!("  十六进制: 0x{:02X}", value);
    
    // 更多转换示例
    println!("\n更多进制转换示例：");
    let values = [0, 1, 8, 16, 64, 128, 255, 1024];
    
    println!("| 十进制 | 二进制     | 八进制 | 十六进制 |");
    println!("|--------|------------|--------|----------|");
    for val in values {
        println!("| {:6} | 0b{:08b} | 0o{:4o} | 0x{:04X}   |", val, val, val, val);
    }
    
    // ===== 第七部分：下划线分隔符的使用 =====
    println!("\n📌 第七部分：下划线分隔符增强可读性");
    
    println!("下划线分隔符的正确使用：");
    
    // 十进制中的下划线
    let large_decimal = 1_000_000_000; // 10亿
    println!("  十进制: 1_000_000_000 = {}", large_decimal);
    
    // 二进制中的下划线（通常按字节分组）
    let binary_bytes = 0b1010_1100_1111_0000; 
    println!("  二进制: 0b1010_1100_1111_0000 = {}", binary_bytes);
    
    // 十六进制中的下划线（通常按字节或字分组）
    let hex_bytes = 0xDEAD_BEEFu32;
    let hex_addr = 0x7FFF_FFFF_8000_0000u64;
    println!("  十六进制: 0xDEAD_BEEF = {}", hex_bytes);
    println!("  十六进制: 0x7FFF_FFFF_8000_0000 = {}", hex_addr);
    
    // ===== 第八部分：类型后缀与进制结合 =====
    println!("\n📌 第八部分：类型后缀与不同进制的结合使用");
    
    println!("不同进制与类型后缀的结合：");
    
    // 各种进制的u8类型
    let dec_u8 = 255u8;
    let bin_u8 = 0b1111_1111u8;
    let oct_u8 = 0o377u8;
    let hex_u8 = 0xFFu8;
    
    println!("  u8类型的不同进制表示（值都是255）：");
    println!("    十进制: 255u8 = {}", dec_u8);
    println!("    二进制: 0b1111_1111u8 = {}", bin_u8);
    println!("    八进制: 0o377u8 = {}", oct_u8);
    println!("    十六进制: 0xFFu8 = {}", hex_u8);
    
    // 各种进制的i32类型
    let dec_i32 = -1000i32;
    let hex_i32 = 0x3E8i32; // 1000的十六进制
    
    println!("\n  i32类型的进制表示：");
    println!("    十进制: -1000i32 = {}", dec_i32);
    println!("    十六进制: 0x3E8i32 = {}", hex_i32);
    
    // ===== 第九部分：格式化输出详解 =====
    println!("\n📌 第九部分：不同进制的格式化输出");
    
    let number = 42;
    
    println!("数值42的各种格式化输出：");
    println!("  {{}} 默认十进制: {}", number);
    println!("  {{:b}} 二进制: {:b}", number);
    println!("  {{:o}} 八进制: {:o}", number);
    println!("  {{:x}} 小写十六进制: {:x}", number);
    println!("  {{:X}} 大写十六进制: {:X}", number);
    
    println!("\n带前缀和填充的格式化：");
    println!("  {{:#b}} 二进制前缀: {:#b}", number);
    println!("  {{:#o}} 八进制前缀: {:#o}", number);
    println!("  {{:#x}} 十六进制前缀: {:#x}", number);
    println!("  {{:08b}} 八位二进制: {:08b}", number);
    println!("  {{:04X}} 四位十六进制: {:04X}", number);
    
    // ===== 第十部分：实际应用场景总结 =====
    println!("\n📌 第十部分：各进制的实际应用场景总结");
    
    println!("🔹 二进制应用场景：");
    println!("  • 位运算和掩码操作");
    println!("  • 标志位和状态管理");
    println!("  • 底层硬件编程");
    println!("  • 权限位设置");
    
    println!("\n🔸 八进制应用场景：");
    println!("  • Unix/Linux文件权限");
    println!("  • 传统系统配置");
    println!("  • 某些嵌入式系统");
    
    println!("\n🔶 十六进制应用场景：");
    println!("  • 内存地址表示");
    println!("  • 颜色值编码（RGB、RGBA）");
    println!("  • 字节数据和哈希值");
    println!("  • 调试和逆向工程");
    println!("  • 网络协议数据");
    
    // ===== 第十一部分：进制转换练习 =====
    println!("\n📌 第十一部分：进制转换练习");
    
    let exercise_values = [
        (0b1010, "二进制 0b1010"),
        (0o12, "八进制 0o12"), 
        (0xA, "十六进制 0xA"),
        (10, "十进制 10")
    ];
    
    println!("验证：以下都表示同一个数值（十进制10）");
    for (val, desc) in exercise_values {
        println!("  {} = {}", desc, val);
    }
    
    // 复杂一点的转换
    println!("\n复杂转换示例（十进制1024）：");
    let kb = 1024;
    println!("  十进制: {}", kb);
    println!("  二进制: 0b{:b} (2的10次方)", kb);
    println!("  八进制: 0o{:o}", kb);
    println!("  十六进制: 0x{:X} (常见的1KB)", kb);
    
    // ===== 总结 =====
    println!("\n🎯 学习总结：");
    println!("1. Rust支持四种进制的整数字面量：十进制、二进制(0b)、八进制(0o)、十六进制(0x)");
    println!("2. 下划线(_)可用于分隔数字增强可读性，不影响数值");
    println!("3. 类型后缀可与任意进制结合使用");
    println!("4. 不同进制适用于不同的应用场景");
    println!("5. 格式化输出可以将数值以任意进制显示");
    println!("6. 选择合适的进制表示可以让代码更清晰易懂");
    
    println!("\n🚀 恭喜！你已经掌握了 Rust 整数字面量的全部进制表示方法！");
}
